home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / glass / glass.lha / GLASS / dtm / typecache.c < prev    next >
C/C++ Source or Header  |  1991-06-18  |  3KB  |  141 lines
  1. /*
  2.    File: typecache.c
  3. */
  4. #include <strings.h>
  5. #include <stdio.h>
  6. #include <cvr.h>
  7. #include <tmc.h>
  8. #include "dtmconst.h"
  9. #include "tmcode.h"
  10. #include "utils.h"
  11. #include "typecache.h"
  12.  
  13. /*
  14.    Because C has only name equivalence instead of type
  15.    equivalence for structures we must cache the coding 
  16.    of all possible Glass types occurring in expressions
  17.    so that we may generate 'typedefs' aforehand for them.
  18. */
  19.  
  20. /*
  21.    Test for type equivalence
  22. */
  23. int equal_typ (t1,t2)
  24.  typ t1,t2;
  25.     { if (t1 -> tag != t2 -> tag) return (0);
  26.       switch (t1 -> tag)
  27.          { case TAGTypBase: return (1);
  28.            case TAGTypIn:
  29.           return (equal_typ (t1 -> TypIn.ityp, t2 -> TypIn.ityp));
  30.            case TAGTypOut:
  31.           return (equal_typ (t1 -> TypOut.otyp, t2 -> TypOut.otyp));
  32.            case TAGTypUni:
  33.           return (equal_typ (t1 -> TypUni.uityp, t2 -> TypUni.uityp) &&
  34.               equal_typ (t1 -> TypUni.uotyp, t2 -> TypUni.uotyp));
  35.            case TAGTypNon:
  36.           return (equal_typ (t1 -> TypNon.nontyp, t2 -> TypNon.nontyp));
  37.            case TAGTypProd:
  38.           { typ_list t1l = t1 -> TypProd.ptypes,
  39.                  t2l = t2 -> TypProd.ptypes;
  40.             register int ix;
  41.             if (t1l -> sz != t2l -> sz) return (0);
  42.             for (ix=0; ix < t1l -> sz; ix++)
  43.                if (!(equal_typ (t1l -> arr[ix], t2l -> arr [ix])))
  44.               return (0);
  45.             return (1);
  46.               };
  47.            case TAGTypSym:
  48.           { return (0);
  49.           };
  50.            default: badtag (t1 -> tag);
  51.          };
  52.     };
  53.  
  54. /*
  55.    Store type in type cache.
  56. */
  57. #define MaxTypeCache 1000
  58. static int typnr=0;
  59. static typ cached_types[MaxTypeCache];
  60.  
  61. void add_to_cache (t)
  62.  typ t;
  63.     { int ix;
  64.       typ_list tl;
  65.       if (t -> tag == TAGTypBase) return;
  66.       if (t -> tag != TAGTypProd)
  67.          { fprintf (stderr, "Only product types may be cached\n");
  68.          };
  69.       for (ix=0; ix < typnr; ix++)
  70.          if (equal_typ (t, cached_types[ix]))
  71.         return;
  72.       tl = t -> TypProd.ptypes;
  73.       for (ix = 0; ix < tl -> sz; ix++)
  74.          add_to_cache (tl -> arr[ix]);
  75.       cached_types [typnr] = rdup_typ (t);
  76.       typnr++;
  77.     };
  78.  
  79. /*
  80.    code type using the cache
  81. */
  82. void code_typ (f,t)
  83.  FILE *f;
  84.  typ t;
  85.     { switch (t -> tag)
  86.          { case TAGTypBase:
  87.           fprintf (f, "int");
  88.           break;
  89.            case TAGTypProd:
  90.           { register int ix;
  91.             for (ix=0; ix < typnr; ix++)
  92.                if (equal_typ (t, cached_types [ix]))
  93.               { fprintf (f, "typ%d", ix);
  94.                 return;
  95.               };
  96.             fprintf (stderr, "type not cached\n");
  97.             exit (1);
  98.           };
  99.           break;
  100.            default: badtag (t -> tag);
  101.          };
  102.     };
  103.  
  104. /*
  105.    code the cached types
  106. */
  107. void code_cached_types (f)
  108.  FILE *f;
  109.     { int ix;
  110.       for (ix = 0; ix < typnr; ix++)
  111.          { int iy;
  112.            typ_list tl = cached_types[ix] -> TypProd.ptypes;
  113.            fprintf (f, "typedef ");
  114.            if (tl -> sz == 0)
  115.           { fprintf (f, "void ");
  116.           }
  117.            else
  118.           { fprintf (f, "struct\n   { ");
  119.             for (iy=0; iy < tl -> sz; iy++)
  120.                { code_typ (f, tl -> arr[iy]);
  121.                  fprintf (f, " f%d;\n", iy);
  122.                  if (iy != tl -> sz - 1)
  123.                     fprintf (f, "     ");
  124.                };
  125.             fprintf (f, "   } ");
  126.           };
  127.            fprintf (f, "typ%d;\n\n", ix);
  128.          };
  129.     };
  130.  
  131. /*
  132.    flush the cached types
  133. */
  134. void flush_cached_types ()
  135.     { int ix;
  136.       for (ix = 0; ix < typnr; ix++)
  137.          rfre_typ (cached_types [ix]);
  138.       typnr = 0;
  139.     };
  140.  
  141.